#include <iostream>
#include <typeinfo>
#include <cassert>

class Any
{
    class holder
    {
    public:
        holder() {};
        virtual ~holder() {};
        virtual holder *clone() = 0;
        virtual const std::type_info &getType() = 0;
    };
    template <class T>
    class placeholder : public holder
    {
    public:
        placeholder(T val) : _val(val)
        {
        }
        virtual ~placeholder()
        {
        }
        virtual holder *clone() { return new placeholder(_val); } // 根据自身克隆出一个holder 并返回
        virtual const std::type_info &getType() { return typeid(_val) ;}

        T _val;  //内部保存任意类型的对象，在创建的Any中有一个holder*指针，
                 //可以去调用placeholder(T val)构造，创建一个placeholder内部保存任意类型的对象
    };

private:
    Any &Swap(Any &me)
    {
        std::swap(_content, me._content);
        return *this;
    }

public:
    Any() { _content = nullptr; }
    template <class T>
    Any(const T &val) : _content(new placeholder<T>(val)) {}
    Any(const Any &a)
    {
        _content = a._content != nullptr ? a._content->clone() : nullptr;
    }
    ~Any()
    {
        delete _content;
    }

    template <class T>
    T *get() // 返回Any存储的数据
    {
        assert(typeid(T) == _content->getType());
        return &((placeholder<T> *)_content)->_val;
    }

    template <class T>
    Any &operator=(const T &val)
    {
        Any a(val);  //构造一个Any，和this换资源
        return a.Swap(*this);
    }

    template <class T>
    Any &operator=(const Any &other)
    {
        Any(other).Swap(*this);
        return *this;
    }

    holder *_content;  //唯一成员变量holder *指针
};
